/**********
This library is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the
Free Software Foundation; either version 2.1 of the License, or (at your
option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)

This library is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
more details.

You should have received a copy of the GNU Lesser General Public License
along with this library; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
**********/
// Copyright (c) 1996-2016, Live Networks, Inc.  All rights reserved
// A test program that demonstrates how to stream - via unicast RTP
// - various kinds of file on demand, using a built-in RTSP server.
// main program

#include "liveMedia.hh"
#include "BasicUsageEnvironment.hh"

UsageEnvironment* env;

// To make the second and subsequent client for each stream reuse the same
// input stream as the first client (rather than playing the file from the
// start for each client), change the following "False" to "True":
Boolean reuseFirstSource = False;

// To stream *only* MPEG-1 or 2 video "I" frames
// (e.g., to reduce network bandwidth),
// change the following "False" to "True":
Boolean iFramesOnly = False;

static void announceStream(RTSPServer* rtspServer, ServerMediaSession* sms,
						   char const* streamName, char const* inputFileName); // fwd

static char newDemuxWatchVariable;

static MatroskaFileServerDemux* matroskaDemux;
static void onMatroskaDemuxCreation(MatroskaFileServerDemux* newDemux, void* /*clientData*/) {
	matroskaDemux = newDemux;
	newDemuxWatchVariable = 1;
}

static OggFileServerDemux* oggDemux;
static void onOggDemuxCreation(OggFileServerDemux* newDemux, void* /*clientData*/) {
	oggDemux = newDemux;
	newDemuxWatchVariable = 1;
}

int main(int argc, char** argv) {
	// Begin by setting up our usage environment:
	TaskScheduler* scheduler = BasicTaskScheduler::createNew();
	env = BasicUsageEnvironment::createNew(*scheduler);

	UserAuthenticationDatabase* authDB = NULL;
#ifdef ACCESS_CONTROL
	// To implement client access control to the RTSP server, do the following:
	authDB = new UserAuthenticationDatabase;
	authDB->addUserRecord("username1", "password1"); // replace these with real strings
	// Repeat the above with each <username>, <password> that you wish to allow
	// access to the server.
#endif

	// Create the RTSP server:
	RTSPServer* rtspServer = RTSPServer::createNew(*env, 8554, authDB);
	if (rtspServer == NULL) {
		*env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
		exit(1);
	}

	char const* descriptionString
		= "Session streamed by \"testOnDemandRTSPServer\"";

	// Set up each of the possible streams that can be served by the
	// RTSP server.  Each such stream is implemented using a
	// "ServerMediaSession" object, plus one or more
	// "ServerMediaSubsession" objects for each audio/video substream.

#pragma region H264
	// A H.264 video elementary stream:
	{
		char const* streamName = "h264ESVideoTest";
		char const* inputFileName = "test.264";
		ServerMediaSession* sms
			= ServerMediaSession::createNew(*env, streamName, streamName,
			descriptionString);
		sms->addSubsession(H264VideoFileServerMediaSubsession
			::createNew(*env, inputFileName, reuseFirstSource));
		rtspServer->addServerMediaSession(sms);

		announceStream(rtspServer, sms, streamName, inputFileName);
	}
#pragma endregion

#pragma region H265
	// A H.265 video elementary stream:
	/*{
	char const* streamName = "h265ESVideoTest";
	char const* inputFileName = "test.265";
	ServerMediaSession* sms
	= ServerMediaSession::createNew(*env, streamName, streamName,
	descriptionString);
	sms->addSubsession(H265VideoFileServerMediaSubsession
	::createNew(*env, inputFileName, reuseFirstSource));
	rtspServer->addServerMediaSession(sms);

	announceStream(rtspServer, sms, streamName, inputFileName);
	}*/
#pragma endregion

#pragma region Mpeg-1 2 audio+video
	// A MPEG-1 or 2 audio+video program stream:
	//{
	//  char const* streamName = "mpeg1or2AudioVideoTest";
	//  char const* inputFileName = "test.mpg";
	//  // NOTE: This *must* be a Program Stream; not an Elementary Stream
	//  ServerMediaSession* sms
	//    = ServerMediaSession::createNew(*env, streamName, streamName,
	//		      descriptionString);
	//  MPEG1or2FileServerDemux* demux
	//    = MPEG1or2FileServerDemux::createNew(*env, inputFileName, reuseFirstSource);
	//  sms->addSubsession(demux->newVideoServerMediaSubsession(iFramesOnly));
	//  sms->addSubsession(demux->newAudioServerMediaSubsession());
	//  rtspServer->addServerMediaSession(sms);

	//  announceStream(rtspServer, sms, streamName, inputFileName);
	//}
#pragma endregion Mpeg-1 2 audio+video

#pragma region Mpge-1 2 video
	// A MPEG-1 or 2 video elementary stream:
	//{
	//  char const* streamName = "mpeg1or2ESVideoTest";
	//  char const* inputFileName = "testv.mpg";
	//  // NOTE: This *must* be a Video Elementary Stream; not a Program Stream
	//  ServerMediaSession* sms
	//    = ServerMediaSession::createNew(*env, streamName, streamName,
	//		      descriptionString);
	//  sms->addSubsession(MPEG1or2VideoFileServerMediaSubsession
	//      ::createNew(*env, inputFileName, reuseFirstSource, iFramesOnly));
	//  rtspServer->addServerMediaSession(sms);

	//  announceStream(rtspServer, sms, streamName, inputFileName);
	//}
#pragma endregion Mpge-1 2 video

#pragma region MP3 audio
	// A MP3 audio stream (actually, any MPEG-1 or 2 audio file will work):
	// To stream using 'ADUs' rather than raw MP3 frames, uncomment the following:
	//#define STREAM_USING_ADUS 1
	// To also reorder ADUs before streaming, uncomment the following:
	//#define INTERLEAVE_ADUS 1
	// (For more information about ADUs and interleaving,
	//  see <http://www.live555.com/rtp-mp3/>)
	//  {
	//    char const* streamName = "mp3AudioTest";
	//    char const* inputFileName = "test.mp3";
	//    ServerMediaSession* sms
	//      = ServerMediaSession::createNew(*env, streamName, streamName,
	//				      descriptionString);
	//    Boolean useADUs = False;
	//    Interleaving* interleaving = NULL;
	//#ifdef STREAM_USING_ADUS
	//    useADUs = True;
	//#ifdef INTERLEAVE_ADUS
	//    unsigned char interleaveCycle[] = {0,2,1,3}; // or choose your own...
	//    unsigned const interleaveCycleSize
	//      = (sizeof interleaveCycle)/(sizeof (unsigned char));
	//    interleaving = new Interleaving(interleaveCycleSize, interleaveCycle);
	//#endif
	//#endif
	//    sms->addSubsession(MP3AudioFileServerMediaSubsession
	//		       ::createNew(*env, inputFileName, reuseFirstSource,
	//				   useADUs, interleaving));
	//    rtspServer->addServerMediaSession(sms);
	//
	//    announceStream(rtspServer, sms, streamName, inputFileName);
	//  }
#pragma endregion

#pragma region WAV audio steam
	// A WAV audio stream:
	//{
	//  char const* streamName = "wavAudioTest";
	//  char const* inputFileName = "test.wav";
	//  ServerMediaSession* sms
	//    = ServerMediaSession::createNew(*env, streamName, streamName,
	//		      descriptionString);
	//  // To convert 16-bit PCM data to 8-bit u-law, prior to streaming,
	//  // change the following to True:
	//  Boolean convertToULaw = False;
	//  sms->addSubsession(WAVAudioFileServerMediaSubsession
	//      ::createNew(*env, inputFileName, reuseFirstSource, convertToULaw));
	//  rtspServer->addServerMediaSession(sms);

	//  announceStream(rtspServer, sms, streamName, inputFileName);
	//}
#pragma endregion WAV audio steam

#pragma region AMR audio stream
	// An AMR audio stream:
	/*{
	char const* streamName = "amrAudioTest";
	char const* inputFileName = "test.amr";
	ServerMediaSession* sms
	= ServerMediaSession::createNew(*env, streamName, streamName,
	descriptionString);
	sms->addSubsession(AMRAudioFileServerMediaSubsession
	::createNew(*env, inputFileName, reuseFirstSource));
	rtspServer->addServerMediaSession(sms);

	announceStream(rtspServer, sms, streamName, inputFileName);
	}*/
#pragma endregion AMR audio stream

#pragma region VOB file
	// A 'VOB' file (e.g., from an unencrypted DVD):
	//{
	//  char const* streamName = "vobTest";
	//  char const* inputFileName = "test.vob";
	//  ServerMediaSession* sms
	//    = ServerMediaSession::createNew(*env, streamName, streamName,
	//		      descriptionString);
	//  // Note: VOB files are MPEG-2 Program Stream files, but using AC-3 audio
	//  MPEG1or2FileServerDemux* demux
	//    = MPEG1or2FileServerDemux::createNew(*env, inputFileName, reuseFirstSource);
	//  sms->addSubsession(demux->newVideoServerMediaSubsession(iFramesOnly));
	//  sms->addSubsession(demux->newAC3AudioServerMediaSubsession());
	//  rtspServer->addServerMediaSession(sms);

	//  announceStream(rtspServer, sms, streamName, inputFileName);
	//}
#pragma endregion VOB file

#pragma region MPEG-2 transport stream
	// A MPEG-2 Transport Stream:
	/* {
	char const* streamName = "mpeg2TransportStreamTest";
	char const* inputFileName = "test.ts";
	char const* indexFileName = "test.tsx";
	ServerMediaSession* sms
	= ServerMediaSession::createNew(*env, streamName, streamName,
	descriptionString);
	sms->addSubsession(MPEG2TransportFileServerMediaSubsession
	::createNew(*env, inputFileName, indexFileName, reuseFirstSource));
	rtspServer->addServerMediaSession(sms);

	announceStream(rtspServer, sms, streamName, inputFileName);
	}*/
#pragma endregion MPEG-2 transport stream

#pragma region  AAC audio stream (ADTS-format file):
	// An AAC audio stream (ADTS-format file):
	/*{
	char const* streamName = "aacAudioTest";
	char const* inputFileName = "test.aac";
	ServerMediaSession* sms
	= ServerMediaSession::createNew(*env, streamName, streamName,
	descriptionString);
	sms->addSubsession(ADTSAudioFileServerMediaSubsession
	::createNew(*env, inputFileName, reuseFirstSource));
	rtspServer->addServerMediaSession(sms);

	announceStream(rtspServer, sms, streamName, inputFileName);
	}*/
#pragma endregion  AAC audio stream (ADTS-format file):

#pragma region DV video stream
	// A DV video stream:
	//{
	//  // First, make sure that the RTPSinks' buffers will be large enough to handle the huge size of DV frames (as big as 288000).
	//  OutPacketBuffer::maxSize = 300000;

	//  char const* streamName = "dvVideoTest";
	//  char const* inputFileName = "test.dv";
	//  ServerMediaSession* sms
	//    = ServerMediaSession::createNew(*env, streamName, streamName,
	//		      descriptionString);
	//  sms->addSubsession(DVVideoFileServerMediaSubsession
	//       ::createNew(*env, inputFileName, reuseFirstSource));
	//  rtspServer->addServerMediaSession(sms);

	//  announceStream(rtspServer, sms, streamName, inputFileName);
	//}
#pragma endregion DV video stream

#pragma region AC3 video elementary stream
	// A AC3 video elementary stream:
	/*{
	char const* streamName = "ac3AudioTest";
	char const* inputFileName = "test.ac3";
	ServerMediaSession* sms
	= ServerMediaSession::createNew(*env, streamName, streamName,
	descriptionString);

	sms->addSubsession(AC3AudioFileServerMediaSubsession
	::createNew(*env, inputFileName, reuseFirstSource));

	rtspServer->addServerMediaSession(sms);

	announceStream(rtspServer, sms, streamName, inputFileName);
	}*/
#pragma endregion AC3 video elementary stream

#pragma region A Matroska ('.mkv') file
	// A Matroska ('.mkv') file, with video+audio+subtitle streams:
	//{
	//  char const* streamName = "matroskaFileTest";
	//  char const* inputFileName = "test.mkv";
	//  ServerMediaSession* sms
	//    = ServerMediaSession::createNew(*env, streamName, streamName,
	//		      descriptionString);

	//  newDemuxWatchVariable = 0;
	//  MatroskaFileServerDemux::createNew(*env, inputFileName, onMatroskaDemuxCreation, NULL);
	//  env->taskScheduler().doEventLoop(&newDemuxWatchVariable);

	//  Boolean sessionHasTracks = False;
	//  ServerMediaSubsession* smss;
	//  while ((smss = matroskaDemux->newServerMediaSubsession()) != NULL) {
	//    sms->addSubsession(smss);
	//    sessionHasTracks = True;
	//  }
	//  if (sessionHasTracks) {
	//    rtspServer->addServerMediaSession(sms);
	//  }
	//  // otherwise, because the stream has no tracks, we don't add a ServerMediaSession to the server.

	//  announceStream(rtspServer, sms, streamName, inputFileName);
	//}
#pragma endregion A Matroska ('.mkv') file

#pragma region WebM
	// A WebM ('.webm') file, with video(VP8)+audio(Vorbis) streams:
	// (Note: ".webm' files are special types of Matroska files, so we use the same code as the Matroska ('.mkv') file code above.)
	//{
	//  char const* streamName = "webmFileTest";
	//  char const* inputFileName = "test.webm";
	//  ServerMediaSession* sms
	//    = ServerMediaSession::createNew(*env, streamName, streamName,
	//		      descriptionString);

	//  newDemuxWatchVariable = 0;
	//  MatroskaFileServerDemux::createNew(*env, inputFileName, onMatroskaDemuxCreation, NULL);
	//  env->taskScheduler().doEventLoop(&newDemuxWatchVariable);

	//  Boolean sessionHasTracks = False;
	//  ServerMediaSubsession* smss;
	//  while ((smss = matroskaDemux->newServerMediaSubsession()) != NULL) {
	//    sms->addSubsession(smss);
	//    sessionHasTracks = True;
	//  }
	//  if (sessionHasTracks) {
	//    rtspServer->addServerMediaSession(sms);
	//  }
	//  // otherwise, because the stream has no tracks, we don't add a ServerMediaSession to the server.

	//  announceStream(rtspServer, sms, streamName, inputFileName);
	//}
#pragma endregion WebM

#pragma region Ogg
	// An Ogg ('.ogg') file, with video and/or audio streams:
	//{
	//  char const* streamName = "oggFileTest";
	//  char const* inputFileName = "test.ogg";
	//  ServerMediaSession* sms
	//    = ServerMediaSession::createNew(*env, streamName, streamName,
	//		      descriptionString);

	//  newDemuxWatchVariable = 0;
	//  OggFileServerDemux::createNew(*env, inputFileName, onOggDemuxCreation, NULL);
	//  env->taskScheduler().doEventLoop(&newDemuxWatchVariable);

	//  Boolean sessionHasTracks = False;
	//  ServerMediaSubsession* smss;
	//  while ((smss = oggDemux->newServerMediaSubsession()) != NULL) {
	//    sms->addSubsession(smss);
	//    sessionHasTracks = True;
	//  }
	//  if (sessionHasTracks) {
	//    rtspServer->addServerMediaSession(sms);
	//  }
	//  // otherwise, because the stream has no tracks, we don't add a ServerMediaSession to the server.

	//  announceStream(rtspServer, sms, streamName, inputFileName);
	//}
#pragma endregion Ogg

#pragma region Opus
	// An Opus ('.opus') audio file:
	// (Note: ".opus' files are special types of Ogg files, so we use the same code as the Ogg ('.ogg') file code above.)
	//{
	//  char const* streamName = "opusFileTest";
	//  char const* inputFileName = "test.opus";
	//  ServerMediaSession* sms
	//    = ServerMediaSession::createNew(*env, streamName, streamName,
	//		      descriptionString);

	//  newDemuxWatchVariable = 0;
	//  OggFileServerDemux::createNew(*env, inputFileName, onOggDemuxCreation, NULL);
	//  env->taskScheduler().doEventLoop(&newDemuxWatchVariable);

	//  Boolean sessionHasTracks = False;
	//  ServerMediaSubsession* smss;
	//  while ((smss = oggDemux->newServerMediaSubsession()) != NULL) {
	//    sms->addSubsession(smss);
	//    sessionHasTracks = True;
	//  }
	//  if (sessionHasTracks) {
	//    rtspServer->addServerMediaSession(sms);
	//  }
	//  // otherwise, because the stream has no tracks, we don't add a ServerMediaSession to the server.

	//  announceStream(rtspServer, sms, streamName, inputFileName);
	//}
#pragma endregion Opus

#pragma region MPEG-2 Transport Stream
	// A MPEG-2 Transport Stream, coming from a live UDP (raw-UDP or RTP/UDP) source:
	//{
	//  char const* streamName = "mpeg2TransportStreamFromUDPSourceTest";
	//  char const* inputAddressStr = "239.255.42.42";
	//      // This causes the server to take its input from the stream sent by the "testMPEG2TransportStreamer" demo application.
	//      // (Note: If the input UDP source is unicast rather than multicast, then change this to NULL.)
	//  portNumBits const inputPortNum = 1234;
	//      // This causes the server to take its input from the stream sent by the "testMPEG2TransportStreamer" demo application.
	//  Boolean const inputStreamIsRawUDP = False; 
	//  ServerMediaSession* sms
	//    = ServerMediaSession::createNew(*env, streamName, streamName,
	//		      descriptionString);
	//  sms->addSubsession(MPEG2TransportUDPServerMediaSubsession
	//       ::createNew(*env, inputAddressStr, inputPortNum, inputStreamIsRawUDP));
	//  rtspServer->addServerMediaSession(sms);

	//  char* url = rtspServer->rtspURL(sms);
	//  *env << "\n\"" << streamName << "\" stream, from a UDP Transport Stream input source \n\t(";
	//  if (inputAddressStr != NULL) {
	//    *env << "IP multicast address " << inputAddressStr << ",";
	//  } else {
	//    *env << "unicast;";
	//  }
	//  *env << " port " << inputPortNum << ")\n";
	//  *env << "Play this stream using the URL \"" << url << "\"\n";
	//  delete[] url;
	//}
#pragma endregion MPEG-2 Transport Stream

	// Also, attempt to create a HTTP server for RTSP-over-HTTP tunneling.
	// Try first with the default HTTP port (80), and then with the alternative HTTP
	// port numbers (8000 and 8080).

	if (rtspServer->setUpTunnelingOverHTTP(80) || rtspServer->setUpTunnelingOverHTTP(8000) || rtspServer->setUpTunnelingOverHTTP(8080)) {
		*env << "\n(We use port " << rtspServer->httpServerPortNum() << " for optional RTSP-over-HTTP tunneling.)\n";
	} else {
		*env << "\n(RTSP-over-HTTP tunneling is not available.)\n";
	}

	env->taskScheduler().doEventLoop(); // does not return

	return 0; // only to prevent compiler warning
}

static void announceStream(RTSPServer* rtspServer, ServerMediaSession* sms,
						   char const* streamName, char const* inputFileName) {
							   char* url = rtspServer->rtspURL(sms);
							   UsageEnvironment& env = rtspServer->envir();
							   env << "\n\"" << streamName << "\" stream, from the file \""
								   << inputFileName << "\"\n";
							   env << "Play this stream using the URL \"" << url << "\"\n";
							   delete[] url;
}
